Qué (quién) es lazy evaluation - definición

EVALUATION STRATEGY THAT DELAYS EVALUATION OF EXPRESSIONS UNTIL ACTUALLY NEEDED

Call by need; Lazy Evaluation; Short circuit (programming); Infinite list; Infinite lists; Lazy evalution; Lazy eval; Lazily evaluated language; Lazy allocation

lazy evaluation

<reduction> An evaluation strategy combining {normal order evaluation} with updating. Under normal order evaluation (outermost or call-by-name evaluation) an expression is evaluated only when its value is needed in order for the program to return (the next part of) its result. Updating means that if an expression's value is needed more than once (i.e. it is shared), the result of the first evaluation is remembered and subsequent requests for it will return the remembered value immediately without further evaluation. This is often implemented by graph reduction. An unevaluated expression is represented as a closure - a data structure containing all the information required to evaluate the expression. Lazy evaluation is one evaluation strategy used to implement non-strict functions. Function arguments may be infinite data structures (especially lists) of values, the components of which are evaluated as needed. According to Phil Wadler the term was invented by Jim Morris. Opposite: eager evaluation. A partial kind of lazy evaluation implements lazy data structures or especially lazy lists where function arguments are passed evaluated but the arguments of data constructors are not evaluated. Full laziness is a program transformation which aims to optimise lazy evaluation by ensuring that all subexpressions in a function body which do not depend on the function's arguments are only evaluated once. (1994-12-14)

Lazy evaluation

In programming language theory, lazy evaluation, or call-by-need, is an evaluation strategy which delays the evaluation of an expression until its value is needed (non-strict evaluation) and which also avoids repeated evaluations (sharing).

https://en.wikipedia.org/wiki/Lazy_evaluation

Lazy (Orlová)

PART OF ORLOVÁ

Lazy (Orlova)

(Polish: ) is a village in Karviná District, Moravian-Silesian Region, Czech Republic. It was a separate municipality but became administratively a part of Orlová in 1946.

https://en.wikipedia.org/wiki/Lazy_(Orlová)

Wikipedia

Lazy evaluation

In programming language theory, lazy evaluation, or call-by-need, is an evaluation strategy which delays the evaluation of an expression until its value is needed (non-strict evaluation) and which also avoids repeated evaluations (sharing).

The benefits of lazy evaluation include:

The ability to define control flow (structures) as abstractions instead of primitives.
The ability to define potentially infinite data structures. This allows for more straightforward implementation of some algorithms.
The ability to define partially-defined data structures where some elements are errors. This allows for rapid prototyping.

Lazy evaluation is often combined with memoization, as described in Jon Bentley's Writing Efficient Programs. After a function's value is computed for that parameter or set of parameters, the result is stored in a lookup table that is indexed by the values of those parameters; the next time the function is called, the table is consulted to determine whether the result for that combination of parameter values is already available. If so, the stored result is simply returned. If not, the function is evaluated and another entry is added to the lookup table for reuse.

Lazy evaluation is difficult to combine with imperative features such as exception handling and input/output, because the order of operations becomes indeterminate.

The opposite of lazy evaluation is eager evaluation, sometimes known as strict evaluation. Eager evaluation is the evaluation strategy employed in most programming languages.

https://en.wikipedia.org/wiki/Lazy evaluation